\subsection{Service-Oriented Architecture}
\begin{figure}[H]
\begin{center}
\includegraphics[scale=0.35]{includes/graphics/architecture_v1.jpg}
\caption{Architecture}
\label{fig:design:architecture}
\end{center}
\end{figure} 

\input{multitier_application.tex}

\subsection{Web Application}
When developing a web applications there are several tools that could be utilized depending on the functionality of the application. The most common tools include HTML, CSS, JavaScript, PHP and ASP.NET, each with its own purpose. HTML (Hyper Text Markup Language) and CSS (Cascading Style Sheet) is used purely for styling the website and has no actual functionality. This means that all functional logic is achieved through scripting languages JavaScript, PHP and ASP.NET. \\ 

PHP and ASP.NET is similar in many ways as they are both server side scripting languages and therefore not used simultaneously. The main difference is platform compatibility as ASP.NET is a product from Microsoft whereas PHP is an open-source alternative. JavaScript is a client side scripting language. Both are able to manipulate HTML objects to create highly dynamic websites. \\
In this project a web application is an intuitive choice because it will make it convenient for our customers to access the services via a standard Web browser.

\subsection{WCF Service} \label{arch:wcf}
Windows Communication Foundation (WCF) is a programming platform used to construct network-distributed systems in a service oriented architecture. Furthermore it is interoperable with services other than .NET which allows WCF to be very flexible in terms of building components. It also contains predefined bindings for the most common communication protocols, such as SOAP over HTTP, TCP etc.. Though while it is easy to setup, it does have a fairly steep learning curve. Furthermore WCF is a fairly high maintenance service, thus still requiring a lot time and resources. \\

\subsubsection{Address, binding and contract}
Our implementation contains a service contract called Service with an Interface called IService. The service defines an Address, Binding and Contract: \\
Address: Address is used for describing the location of a service and the protocols that can be used for communicating with the service, in our case localhost. \\
Binding: The binding type we have chosen in this project is a BasicHttpBinding. The BasicHttpBinding uses HTTP as the transport for sending SOAP 1.1 messages between the client and the service. \\
Contract: A data contract is an agreement between a service and a client, that abstractly describes the data to be exchanged. This means in order to communicate, the client and service do not have to share the same types, only the same data contracts. A data contract defines precisely, for each parameter or return type, what data is serialized (transformed into XML(Soap)) to be exchanged.

\begin{figure}[H]
\begin{center}
\includegraphics[scale=0.65]{includes/graphics/MyGUIConfig.png}
\caption{GUI config code snippet}
\label{fig:architecture:GUIConfig}
\end{center}
\end{figure}

\subsection{Bindings}
There are different kind of bindings which can be used to exchange information between a client and a server. In this section, we will look at basichttpbinding and WsHttpBinding. \\ 
Basichttpbinding and WsHttpBinding uses SOAP. Basichttpbinding is aimed at clients who has .net 3,0 or lower and supports a wider range of clients. Windows 2000 does not support .net 3,0, thus this would be the binding to use. Furthermore basichttpbinding cannot handle several requests from one client as they do not necessarily return it in the same order as they where called. By default the binding does not encrypt data.
WsHttpBinding is aimed at clients who have .net 3,0 or higher. It can handle multiple request at the same time and it is encrypted by default.

\subsubsection{DataContract and DataMember}
$[$DataContract$]$ is used to declare objects in the model layer that are to be used in the Client, accessed through the WCF service. This is done by writing $[$DataContract$]$ above the name of the class in question. In case of inheritance the superclass is to define its subclasses by writing the following be the superclass: \\
$[$KnownType(typeof(subclass1))$]$\\
$[$KnownType(typeof(subclass2))$]$\\

$[$DataMember$]$ is used to declare the methods and properties from the model layer that are to used in the Client, accessed through the WCF service, this is done by placing $[$DataContract$]$ above each method or property. \\

$[$ServiceContract$]$ is used for creating the service contracts in the WCF IService interface by writing it above the name of the interface. \\
$[$OperationContract$]$ is used for creating operation contracts for methods specified in the WCF IService interface by writing it above the given methods.

\paragraph{Timeout duration:}
The following are used in the App.config file on the client in order to enable slower operations to finish instead of timing out: \\ 
maxReceivedMessageSize="2147483647" closeTimeout="00:02:00" openTimeout="00:02:00" sendTimeout="00:02:00" receiveTimeout="00:10:00"

\subsection{Domain Considerations}
One of the considerations of the domain is whether or not an online web application can have an effect on the performance an airport's local application.
This is an important consideration to make since you want to avoid threats an airport's overall security and functional performance. Aspects such as too much traffic and online cyber attacks are relevant concerns that might come to affect the performance of the daily work at an airport, if not taken into consideration. In other words; one should seek to avoid that the local domain application at the airport does not become too dependable, or even worse, reliant, on the web domain. This can be ensured by focusing on the isolation of the two domains as much as possible, while prioritising modularity, thus bettering maintenance.